import sys
input = sys.stdin.readline
from collections import deque

N = int(input().strip())
grid = [list(input().strip()) for _ in range(N)]

# 방향 벡터 
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

def bfs(x, y, color, visited, grid):
    queue = deque([(x, y)]) # 큐 초기화 및 시작점 추가 
    visited[x][y] = True # 방문 처리 
    
    while queue:
        x, y = queue.popleft() # 큐에서 하나를 꺼냄
        for i in range(4): # 상하좌우 탐색
            nx, ny = x + dx[i], y + dy[i]
            # 새로운 위치가 범위 내에 있고, 방문하지 않았으며, 같은 색이면 탐색 진행 
            if 0 <= nx < N and 0 <= ny < N and not visited[nx][ny]:
                if grid[nx][ny] == color:
                    visited  [nx][ny] = True # 방문 처리
                    queue.append((nx, ny)) # 큐에 추가 

def count_regions(grid, is_color_blind):
    visited = [[False] * N for _ in range(N)]
    count = 0

    for i in range(N):
        for j in range(N):
            if not visited[i][j]:  # 방문하지 않은 경우 BFS 탐색 시작
                count += 1
                color = grid[i][j]

                # 적록색약 모드라면 R과 G를 동일하게 처리
                if is_color_blind and color in "RG":
                    bfs(i, j, "R", visited, grid)
                else:
                    bfs(i, j, color, visited, grid)
    
    return count

# 적록색약이 아닌 경우 
normal_count = count_regions(grid, is_color_blind=False)

# 적록색약인 경우 (R과 G를 동일하게 처리한 grid 생성)
 for i in range(N):
   for j in range(N):
        if grid[i][j] == 'G':
            grid[i][j] = 'R'
                   
color_blind_count = count_regions(grid, is_color_blind=True)
print(normal_count, color_blind_count)

import sys
input = sys.stdin.readline
from collections import deque

# 8방향 (상, 하, 좌, 우, 대각선 4개)
dx = [-1, 1, 0, 0, -1, -1, 1, 1]
dy = [0, 0, -1, 1, -1, 1, -1, 1]

def bfs(x, y, graph, w, h):
    queue = deque([(x, y)])
    graph[y][x] = 0  # 방문 처리 (1 → 0 변경)

    while queue: # 큐가 빌 때까지 반복
        cx, cy = queue.popleft() # 현재 좌표 꺼내기 
        for i in range(8):  # 8방향 탐색
            nx, ny = cx + dx[i], cy + dy[i] # 새로운 좌표 계산
            if 0 <= nx < w and 0 <= ny < h and graph[ny][nx] == 1:
                graph[ny][nx] = 0  # 방문 처리
                queue.append((nx, ny)) # 큐에 추가 (다음에 탐색할 곳)
 
while True:
    w, h = map(int, input().split())
    if w == 0 and h == 0:
        break  # 종료 조건
    island = [list(map(int, input().split())) for _ in range(h)]

    count = 0 # 섬의 개수 
    for y in range(h):
        for x in range(w):
            if island[y][x] == 1:  # 새로운 섬 발견
                count += 1
                bfs(x, y, island, w, h) # BFS 실행
    
    print(count)

import sys 
input = sys.stdin.readline

N, M = map(int, input().split())
grid = [list(map(int, input().split())) for _ in range(N)]

dp = [[0] * M for _ in range(N)]
dp[0][0] = grid[0][0]

def max_resources(N, M, grid):
    # 첫 번째 행 채우기
    for j in range(1, M):
        dp[0][j] = dp[0][j-1] + grid[0][j]

    # 첫 번째 열 채우기
    for i in range(1, N):
        dp[i][0] = dp[i-1][0] + grid[i][0]

    # DP 테이블 채우기
    for i in range(1, N):
        for j in range(1, M):
            dp[i][j] = max(dp[i-1][j], dp[i][j-1]) + grid[i][j]

    return dp[N-1][M-1]

print(max_resources(N, M, grid))

import sys 
input = sys.stdin.readline
from itertools import permutations

N = int(input().strip()) # 질문 횟수 
questions = [list(map(int, input().split())) for _ in range(N)] # 질문 리스트

# 1부터 9까지의 숫자 중 3개를 뽑는 순열
nums = list(permutations(range(1,10), 3)) 
cnt = 0 # 가능한 경우의 수

# 두 수를 비교하여 스트라이크와 볼을 반환
def strike_and_ball(num1, num2):
    strike = sum(a == b for a, b in zip(num1, num2))
    ball = sum(a in num2 for a in num1) - strike
    return strike, ball 
    
for num in nums:
    num_str = ''.join(map(str, num)) # 순열을 문자열로 변환
    valid = True # 가능한 숫자인지 판별
    
    for q_num, q_strike, q_ball in questions:
        q_str = str(q_num) # 입력된 숫자도 문자열 변환 
        strike, ball = strike_and_ball(num_str, q_str)
        if strike != q_strike or ball != q_ball:
            valid = False
            break  # 하나라도 불가능하면 더 볼 필요 없음
    
    if valid:
        cnt += 1

print(cnt)

import sys 
input = sys.stdin.readline

steps = list(map(int, input().split()))
if steps: 
    steps.pop()  # 마지막 0 제거

# dp 테이블
INF = float('inf') # 무한대 값 
dp = [[INF]*5 for _ in range(5)]
dp[0][0] = 0

def move_power(start, end):
    if start == 0: # 중앙에서 다른 곳으로 이동하는 경우 
        return 2
    if start == end: # 같은 지점을 연속해서 밟는 경우 
        return 1 
    if abs(start - end) == 2: # 반대편으로 이동하는 경우
        return 4 
    return 3 # 인접한 지점으로 이동하는 경우

for step in steps:
    new_dp = [[INF]*5 for _ in range(5)] # 새로운 dp 테이블
    
    for left in range(5):
        for right in range(5):
            if dp[left][right] == INF:
                continue 
            
            current_power = dp[left][right] # 현재 위치의 힘의 소모량
            
            # 왼발을 움직이는 경우 (오른발이 step에 있으면 안 됨)
            if step != right:
                new_dp[step][right] = min(new_dp[step][right], current_power + move_power(left, step))

            # 오른발을 움직이는 경우 (왼발이 step에 있으면 안 됨)
            if step != left:
                new_dp[left][step] = min(new_dp[left][step], current_power + move_power(right, step))
    
    dp = new_dp # dp 테이블 업데이트

print(min(min(row) for row in dp)) 

import sys 
input = sys.stdin.readline

n, k = map(int, input().split())
coins = [int(input()) for _ in range(n)]

dp = [0] * (k + 1)
dp[0] = 1 # 0원을 만드는 경우의 수는 1 (아무 동전도 사용하지 않는 경우)

for coin in coins: 
    for j in range(coin, k+1):
        dp[j] += dp[j - coin] # 점화식

print(dp[k])